#include<iostream>
#include<string>

#include <cmath>
#include <unistd.h>
#include <sstream>
#include "SFML/Network.hpp"
#include "SFML/Graphics.hpp"

#include "Server.h"
#include "Partie.h"
#include "Etat.h"
#include "Carte.hpp"
#include "Camp.hpp"
#include "Reglesbase.h"

#define DEBUG true


/*
 * A faire :
 *
 * Pour la gestion d'une partie :
 * A chaque nouveau client ajoute, il doit se connecté à la partie 
 * sur le port "50001".
 * La partie enverra la données au client via ce port,
 * l'autre (50000) servira pour les echange avec le server
 *
 * A ajouter ici la gestion d'une connection et la sauvegarde de la BR
 * sur le nouveau port.
 * De meme pour le coté client.
 *
 */

using namespace std;


Partie::Partie( int nombreJoueurMax, sf::TcpListener * listen, sf::SocketSelector * select ) : nombreJoueurs(nombreJoueurMax), listener(listen), selector(select)
{
	map = new Carte();

	T1 = -1;
	T2 = -1;

    joueurActuel = 0;
}

Partie::~Partie()
{
	delete map;
	map = NULL;

	if(DEBUG) { cout << "Carte Supprime" << endl; }
}


void Partie::genererCarte( int nbTparJ )
{
	// **************
	/// Code d'Amin :
	// **************
	
	if(DEBUG)
	{ cout << "Generer carte !" << endl; }
	
	do
	{
		cout << "1 & " << endl;
		map->clear();
		cout << "2 & " << endl;
		map->genererCarte(nombreJoueurs, nbTparJ);
		cout << "3 & " << endl;
	} while( ! map->composante() );

	camps = new Camp[nombreJoueurs];

	for(int i(0);i<nombreJoueurs;i++)
	{
		camps[i].setIndice(i);
	}

	map->repartirTerritoires( nombreJoueurs, nbTparJ, camps );

    for(int i(0);i<nombreJoueurs;i++)
    {
        deploiAleaDes(camps[i], 2 * nbTParJoueur(nombreJoueurs), true);
    }

	if(DEBUG)
	{ cout << "Carte OK !" << endl; }
}

int Partie::nbTParJoueur( int nbJ )
{
	// a l'entier superieuceil(32 / nbJ);r :
//	cout << "-------------" <<  ceil(32 / nbJ) << endl;
	
	return ceil(32 / nbJ);
}


bool Partie::uniqueJoueur()
{
	bool result=true;
      int taille=map->getNbTerr();
      int i = 0;
	int indcampbase=(map->territoires[i])->getIndiceCamp();
  i = 1;
    while((i<taille)&&(result))
    {
      if(indcampbase!=(map->territoires[i])->getIndiceCamp())
        {
          result=false;
        }
        i++;
    }
    return result;

}


void Partie::deploiAleaDes(Camp& c, int nbDesADeploi, bool vite )
{
	int des=nbDesADeploi;
	int indalea;
    int nombreterr=c.nbTerritoire();
    vector<Territoire*> ter=c.getTerritoires();

    cout << joueurActuel << " ..." << endl;
    bool co = true;

    sf::Packet pp;

    if(!vite)
    {
        for( std::map<string, Client*>::iterator tr = clients.begin(); tr != clients.end(); tr++)
        {
            if( (*tr).second != NULL)
            {
                pp.clear();
                pp << eGAME_DEPLOY;
                (*tr).second->BR_partie->send( pp );

                pp.clear();
                pp << (sf::Uint8)c.getIndice() << (sf::Uint8)des;
                (*tr).second->BR_partie->send( pp );
            }
        }

        cout << "DEPLOI C:" << c.getIndice() << " nbD:" << des << endl;
    }

    while(des>0 && co)
    {
        co = false;
        for(int k=0; k<nombreterr;k++)
        {
            if(ter[k]->getNbDesCourant() < 8)
            {
                co = true;
            }
        }

        if(co)
        {
            indalea=(rand()%nombreterr);
            //cout << " gain: " << ter[indalea]->getIndice() << "  c-" << ter[indalea]->getIndiceCamp() << endl;

            if(ter[indalea]->ajouterDes())
            {
                des--;

                if(!vite)
                {

                    for( std::map<string, Client*>::iterator tr = clients.begin(); tr != clients.end(); tr++)
                    {
                        if( (*tr).second != NULL)
                        {
                            pp.clear();
                            pp << (sf::Int8)ter[indalea]->getIndice();
                            (*tr).second->BR_partie->send( pp );
                        }
                    }

                    cout << "DEPLOI T:" << ter[indalea]->getIndice() << endl;

                    usleep(300 * 500);
                }
            }
        }
	}

    while(des>0 && !vite)
    {
        for( std::map<string, Client*>::iterator tr = clients.begin(); tr != clients.end(); tr++)
        {
            if( (*tr).second != NULL)
            {
                pp.clear();
                pp << (sf::Int8)-1;
                (*tr).second->BR_partie->send( pp );
            }
        }
        cout << "vide" << endl;
        des--;
    }
}



bool Partie::ajouterJoueur( pair<string, Client *> client )
{
	if( (int)clients.size() < nombreJoueurs)
	{
		return true;
	}
	else
	{
		return false;
	}
}


void Partie::infoNewJoueur( pair<string, Client*> client)
{
	clients.insert( client );
	client.second->ready = false;
	
	sf::Packet p;
	p << eMAIN_ALLCLIENTGAME;
	client.second->BR_partie->send( p );

//	cout << "taille === " << clients.size() << client.first << endl;
	
	p.clear();
	p << (int)clients.size();
	client.second->BR_partie->send( p );


	for(std::map<string, Client*>::iterator it = clients.begin(); it != clients.end(); it++)
	{
        if((*it).second != NULL)
        {
//		cout << "nom ...... " << (*it).first << endl;

            p.clear();
            p << (*it).first;
            client.second->BR_partie->send( p );

            if( (*it).first != client.first )
            {
                sf::Packet packet;
                packet << eMAIN_NEWCLSALON;
                (*it).second->BR_partie->send( packet );

                packet.clear();
                packet << client.first;
                (*it).second->BR_partie->send( packet );
            }
        }
	}
}


bool Partie::retirerJoueur( std::pair<string, Client*> client )
{
	selector->remove( * client.second->BR_partie );
	
	clients.erase(client.first);

	for(std::map<string, Client*>::iterator it = clients.begin(); it != clients.end(); it++)
	{
        if((*it).second != NULL)
        {
            sf::Packet packet;
            packet << eMAIN_DELCLSALON;
            (*it).second->BR_partie->send( packet );

            packet.clear();
            packet << client.first;
            (*it).second->BR_partie->send( packet );
        }
	}

	return clients.size() > 0;
}

void Partie::run()
{
	genererCarte( nbTParJoueur(nombreJoueurs));

	sendMap();

	
	if(DEBUG) { cout << "Debut Partie" << endl; }

	int k = 0;
	for(std::map<string, Client*>::iterator it = clients.begin(); it != clients.end(); it++)
	{
        if((*it).second != NULL)
        {
            sf::Packet packet;
            packet << (sf::Uint8)k;
            (*it).second->BR_partie->send( packet );

            packet.clear();
            packet << eGAME_ETAT;
            //(*it).second->BR_partie->send( packet );

            packet.clear();
            packet << (sf::Uint8)eATTENTE;
            (*it).second->BR_partie->send( packet );
            camps[k].setEtat( eATTENTE );
        }
		k++;
	}

    for(std::map<string, Client*>::iterator it = clients.begin(); it != clients.end(); it++)
    {
        if((*it).second != NULL)
        {
            for(int f=0;f<map->getNbTerr();f++)
            {
                sf::Packet pp;
                pp << eGAME_TMAJ;
                (*it).second->BR_partie->send( pp );

                pp.clear();
                pp << (sf::Int8)f << (sf::Uint8)map->territoires[f]->getNbDesCourant() << (sf::Uint8)map->territoires[f]->getIndiceCamp() << (sf::Uint8)(f==map->getNbTerr()-1?1:0);
                (*it).second->BR_partie->send( pp );
            }
        }
    }

	cout << "Etat de base OK" << endl;

	sf::Packet p;
	p << eGAME_ETAT;
	std::map<string, Client*>::iterator d = clients.begin();
	(*d).second->BR_partie->send( p );

	p.clear();
	p << (sf::Uint8)eCOMBAT;
	(*d).second->BR_partie->send( p );
	//joueurActuel = & camps[0];
	camps[0].setEtat( eCOMBAT );
    joueurActuel = 0;

	cout << "OKOK" << endl;
	
    while(! uniqueJoueur())
	{
        usleep(200 * 500);

		if(selector->wait( sf::milliseconds( 60 ) ) )
		{
            //cout << "e" << endl;
			for( std::map<string, Client*>::iterator it = clients.begin(); it != clients.end(); it++)
			{
                if((*it).second != NULL && selector->isReady( *((*it).second->BR_partie ) ) )
				{
					int event;
					sf::Packet p;

					(*it).second->BR_partie->receive( p );
					p >> event;

					cout << "new event de : " << (*it).first << "[" << event << "]" << endl;

					switch( event )
					{
						case eGAME_SELECTION :
						{
							sf::Int8 g;
							int t = -1;
							sf::Packet p;
							(*it).second->BR_partie->receive(p);
							p >> g;
                            t = (int)g;

							if(T1 != -1 && t != -1)
							{
								T2 = t;
							}
							else
							{
								T1 = t;
							}

							for( std::map<string, Client*>::iterator tr = clients.begin(); tr != clients.end(); tr++)
							{
                                if((*tr).second != NULL)
                                {
                                    sf::Packet pp;
                                    pp << eGAME_SELECTION;
                                    (*tr).second->BR_partie->send( pp );

                                    pp.clear();
                                    g = (sf::Int8)T1;
                                    sf::Int8 g2 = (sf::Int8)T2;

                                    pp << g << g2;
                                    (*tr).second->BR_partie->send( pp );
                                }
							}

						} break;

						case eGAME_ETAT :
						{
                        	JoueurSuivant();
                            /*else
							{
								camps[n].setEtat( eCOMBAT );
							}*/

														
						} break;

						case eMAIN_DECOCLIENT :
						{
							string nom = (*it).first;
							selector->remove( * clients[nom]->BR_partie );

                            delete clients[nom];
                            clients[nom] = NULL;
                            //it--;
							cout << "-1 joueur" << endl;
                            bool bb = true;
                            for( std::map<string, Client*>::iterator tr = clients.begin(); tr != clients.end(); tr++)
                            {
                                if( (*tr).second != NULL )
                                {
                                    bb = false;
                                }
                            }
                            if(bb) { cout << "KILL!" << endl; exit(0); }
						} break;

						default:
							break;
					}
				}
            }
        }

        //cout << "j:" << joueurActuel << endl;

        if(joueurActuel < clients.size())
        {
            std::map<string, Client*>::iterator itr = clients.begin();
            for(int k=0;k<joueurActuel;k++)
            {
                itr++;
            }
            if((*itr).second == NULL)
            {
                combatIAsimple(& camps[joueurActuel]);
                JoueurSuivant();
            }
        }


        while( joueurActuel >= (int)clients.size() && ! uniqueJoueur())
        {
            // IA :
            combatIAsimple(& camps[joueurActuel]);
            JoueurSuivant();
        }


		if(T1 != -1 && T2 != -1)
		{
            regles.attaquer( map->territoires[T1], map->territoires[T2], camps, clients );
			//T1 = -1;
			//T2 = -1;

            usleep(1100 * 500);

			for( std::map<string, Client*>::iterator tr = clients.begin(); tr != clients.end(); tr++)
			{
                if((*tr).second != NULL)
                {
                    sf::Packet pp;
                    pp << eGAME_TMAJ;
                    (*tr).second->BR_partie->send( pp );

                    pp.clear();
                    pp << (sf::Int8)T1 << (sf::Uint8)map->territoires[T1]->getNbDesCourant() << (sf::Uint8)map->territoires[T1]->getIndiceCamp() << (sf::Uint8)1;
                    (*tr).second->BR_partie->send( pp );


                    pp.clear();
                    pp << eGAME_TMAJ;
                    (*tr).second->BR_partie->send( pp );

                    pp.clear();
                    pp << (sf::Int8)T2 << (sf::Uint8)map->territoires[T2]->getNbDesCourant() << (sf::Uint8)map->territoires[T2]->getIndiceCamp() << (sf::Uint8)1;
                    (*tr).second->BR_partie->send( pp );

                    cout << "T1 => D:" << map->territoires[T1]->getNbDesCourant() << " C:" << map->territoires[T1]->getIndiceCamp() << endl;
                    cout << "T2 => D:" << map->territoires[T2]->getNbDesCourant() << " C:" << map->territoires[T2]->getIndiceCamp() << endl;
                }
			}

			T1 = -1;
			T2 = -1;

			for( std::map<string, Client*>::iterator tr = clients.begin(); tr != clients.end(); tr++)
			{
                if((*tr).second != NULL)
                {
                    sf::Packet pp;
                    pp << eGAME_SELECTION;
                    (*tr).second->BR_partie->send( pp );

                    pp.clear();
                    pp << (sf::Int8)-1 << (sf::Int8)-1;
                    (*tr).second->BR_partie->send( pp );
                }
			}

			cout << "fin_combat" << endl;
		}
	}

    for( std::map<string, Client*>::iterator tr = clients.begin(); tr != clients.end(); tr++)
    {
        if((*tr).second != NULL)
        {
            sf::Packet pp;
            pp << eGAME_WIN;
            (*tr).second->BR_partie->send( pp );

            string nom;
            std::map<string, Client*>::iterator ft = clients.begin();
            for(int k=0;k<clients.size();k++)
            {
                if(map->territoires[0]->getIndiceCamp() == k)
                {
                    k = clients.size();
                }
                else
                {
                    ft++;
                }
            }

            if(ft == clients.end())
            {
                nom = "BOT ";
                stringstream oss;
                oss <<  map->territoires[0]->getIndiceCamp() - clients.size() + 1 ;
                nom.append(oss.str());
            }
            else
            {
                nom = (*ft).first;
            }

            pp.clear();
            pp << nom;
            (*tr).second->BR_partie->send( pp );
        }
    }


	if(DEBUG) { cout << "Partie termine" << endl; }
    exit(0);
	// Fin ;)
}


void Partie::setReady( string nomJoueur )
{
	if(clients.find(nomJoueur) != clients.end())
	{
		clients[nomJoueur]->ready = true;
	}
}


bool Partie::allReady()
{
	for(std::map<string, Client*>::iterator it = clients.begin(); it != clients.end(); it++)
	{
        if((*it).second != NULL && ! (*it).second->ready )
		{
			return false;
		}
	}

	return true;
}



int Partie::getNbJoueur()
{ return clients.size(); }

int Partie::getNbJoueurMax()
{ return nombreJoueurs; }




void Partie::sendMap()
{
	if(DEBUG)
	{ cout << "Send MAP : " << endl; }
	
	for(std::map<string, Client*>::iterator it = clients.begin(); it != clients.end(); it++)
	{
        if((*it).second != NULL)
        {
            if(DEBUG)
            { cout << "\tSend to : " << (*it).first << endl; }

            sf::Vector2i* l = map->getCentres();

            sf::Packet p;
            p << (sf::Uint8)nombreJoueurs << (sf::Uint8)nbTParJoueur(nombreJoueurs);
            (*it).second->BR_partie->send( p );

            p.clear();
            p << (sf::Uint8)map->getNbTerr();
            (*it).second->BR_partie->send( p );

            for(int i(0); i<map->getNbTerr();i++)
            {
                p.clear();
                p << (sf::Uint8)l[i].x << (sf::Uint8)l[i].y ;
                (*it).second->BR_partie->send( p );
            }



            if(DEBUG)
            { cout << "\tFin !" << endl << endl; }
        }
	}
}


void Partie::combatIAsimple(Camp* c)
{
    Territoire * t_atk = NULL;
    vector<Territoire*> tab[8];
    for(int i(0);i<c->nbTerritoire();i++)
    {
        tab[c->territoires[i]->getNbDesCourant()-1].push_back(c->territoires[i]);
    }

    for(int d=7;d>0;d--)
    {
        cout << "***d" << d << endl;
        for(vector<Territoire*>::iterator t=tab[d].begin();t!=tab[d].end();t++)
        {
            cout << "nt:" << (*t)->getIndice() << endl;
            t_atk = NULL;
            int min(d+2);

            vector<int> voisinss = (*t)->getVoisins();

            for(vector<int>::iterator v = voisinss.begin(); v!=voisinss.end(); v++)
            {
                cout << "sv-" << (*v) << endl;
                if(map->territoires[(*v)]->getNbDesCourant() < min)
                {
                    min = map->territoires[(*v)]->getNbDesCourant();
                    t_atk = map->territoires[(*v)];
                }
                cout << "s" << endl;
            }

            cout << "att" << endl;

            // ATTAQUE :

            if(t_atk != NULL && (*t)->attaquable(t_atk))
            {
                bool w = regles.attaquer((*t), t_atk, camps, clients);
                if(w)
                {
                    tab[d-1].push_back(t_atk);
                }
                cout << "\t\tIA - attaque" << endl;

                for( std::map<string, Client*>::iterator tr = clients.begin(); tr != clients.end(); tr++)
                {
                    if((*tr).second != NULL)
                    {
                        sf::Packet pp;
                        pp << eGAME_SELECTION;
                        (*tr).second->BR_partie->send( pp );

                        pp.clear();
                        pp << (sf::Int8)(*t)->getIndice() << (sf::Int8)t_atk->getIndice();
                        (*tr).second->BR_partie->send( pp );
                    }
                }

                usleep(1111 * 500);


                for( std::map<string, Client*>::iterator tr = clients.begin(); tr != clients.end(); tr++)
                {
                    if((*tr).second != NULL)
                    {
                        sf::Packet pp;
                        pp << eGAME_TMAJ;
                        (*tr).second->BR_partie->send( pp );

                        pp.clear();
                        pp << (sf::Int8)(*t)->getIndice() << (sf::Uint8)(*t)->getNbDesCourant() << (sf::Uint8)(*t)->getIndiceCamp() << (sf::Uint8)1;
                        (*tr).second->BR_partie->send( pp );


                        pp.clear();
                        pp << eGAME_TMAJ;
                        (*tr).second->BR_partie->send( pp );

                        pp.clear();
                        pp << (sf::Int8)t_atk->getIndice() << (sf::Uint8)t_atk->getNbDesCourant() << (sf::Uint8)t_atk->getIndiceCamp() << (sf::Uint8)1;
                        (*tr).second->BR_partie->send( pp );

                        cout << "\t ia - T" << (*t)->getIndice() << " => D:" << (*t)->getNbDesCourant() << " C:" << (*t)->getIndiceCamp() << endl;
                        cout << "\t ia - T" << t_atk->getIndice() << " => D:" << t_atk->getNbDesCourant() << " C:" << t_atk->getIndiceCamp() << endl;

                    }
                }


                T1 = -1;
                T2 = -1;

                for( std::map<string, Client*>::iterator tr = clients.begin(); tr != clients.end(); tr++)
                {
                    if((*tr).second != NULL)
                    {
                        sf::Packet pp;
                        pp << eGAME_SELECTION;
                        (*tr).second->BR_partie->send( pp );

                        pp.clear();
                        pp << (sf::Int8)-1 << (sf::Int8)-1;
                        (*tr).second->BR_partie->send( pp );
                    }
                }
            }

            if(uniqueJoueur()) { return; }
            cout << "ft" << endl;
        }
    }


    // *****************************************************************************

    /* ANCIENNE IA

    for(int i(0);i<c->nbTerritoire();i++)
	{
        if(uniqueJoueur()) { return; }
        sleep(0.2);

		int j(0);
		vector<int> voisinss = c->territoires[i]->getVoisins();
        int taillevoisins = voisinss.size();

        int v = c->territoires[i]->getIndice();

        while((c->territoires[i]->actionPossible())&&(j<taillevoisins))
		{
            if(c->territoires[i]->attaquable(map->territoires[voisinss[j]]) && c->territoires[i]->getNbDesCourant() >= map->territoires[voisinss[j]]->getNbDesCourant())
            {
                regles.attaquer(c->territoires[i], map->territoires[voisinss[j]], camps);
                cout << "\t\tIA - attaque" << endl;

				for( std::map<string, Client*>::iterator tr = clients.begin(); tr != clients.end(); tr++)
				{
                    if((*tr).second != NULL)
                    {
                        sf::Packet pp;
                        pp << eGAME_SELECTION;
                        (*tr).second->BR_partie->send( pp );

                        pp.clear();
                        pp << (sf::Int8)v << (sf::Int8)voisinss[j];
                        (*tr).second->BR_partie->send( pp );
                    }
				}

                sleep(1);


				for( std::map<string, Client*>::iterator tr = clients.begin(); tr != clients.end(); tr++)
				{
                    if((*tr).second != NULL)
                    {
                        sf::Packet pp;
                        pp << eGAME_TMAJ;
                        (*tr).second->BR_partie->send( pp );

                        pp.clear();
                        pp << (sf::Int8)v << (sf::Uint8)c->territoires[i]->getNbDesCourant() << (sf::Uint8)c->territoires[i]->getIndiceCamp() << (sf::Uint8)1;
                        (*tr).second->BR_partie->send( pp );


                        pp.clear();
                        pp << eGAME_TMAJ;
                        (*tr).second->BR_partie->send( pp );

                        pp.clear();
                        pp << (sf::Int8)voisinss[j] << (sf::Uint8)map->territoires[voisinss[j]]->getNbDesCourant() << (sf::Uint8)map->territoires[voisinss[j]]->getIndiceCamp() << (sf::Uint8)1;
                        (*tr).second->BR_partie->send( pp );

                        cout << "\t ia - T" << v << " => D:" << map->territoires[v]->getNbDesCourant() << " C:" << map->territoires[v]->getIndiceCamp() << endl;
                        cout << "\t ia - T" << voisinss[j] << " => D:" << map->territoires[voisinss[j]]->getNbDesCourant() << " C:" << map->territoires[voisinss[j]]->getIndiceCamp() << endl;
                    }
				}


				T1 = -1;
				T2 = -1;

				for( std::map<string, Client*>::iterator tr = clients.begin(); tr != clients.end(); tr++)
				{
                    if((*tr).second != NULL)
                    {
                        sf::Packet pp;
                        pp << eGAME_SELECTION;
                        (*tr).second->BR_partie->send( pp );

                        pp.clear();
                        pp << (sf::Int8)-1 << (sf::Int8)-1;
                        (*tr).second->BR_partie->send( pp );
                    }
				}	




			}

            cout << "\t\tIA - new target" << endl;
            j++;
		}

        cout << "\t\tIA - new terr" << endl;
	}
    */
}


void Partie::JoueurSuivant()
{
    if( camps[joueurActuel].getEtat() == eCOMBAT )
    {

        camps[joueurActuel].setEtat( eATTENTE );

        std::map<string, Client*>::iterator it = clients.end();
        std::map<string, Client*>::iterator tt = it;
        if(joueurActuel < (int)clients.size())
        {
            int j=0;
            for(it = clients.begin(); it != clients.end(); it++)
            {
                if(j==joueurActuel)
                {
                    tt = it;
                    it = clients.end();
                }
                j++;
            }
        }

        if(tt != clients.end() && (*tt).second != NULL)
        {

            sf::Packet p;
            p << eGAME_ETAT;
            (*tt).second->BR_partie->send( p );

            p.clear();
            p << (sf::Uint8)camps[joueurActuel].getEtat();
            (*tt).second->BR_partie->send( p );
        }

        deploiAleaDes(camps[joueurActuel], camps[joueurActuel].nbDesADeploi(map->getNbTerr(), map->territoires), false);


        do
        {
            if(tt != clients.end()) { tt++; }
            joueurActuel++;
            if(joueurActuel >= nombreJoueurs)
            {
                 joueurActuel = 0;
                 tt = clients.begin();
            }
        } while(camps[joueurActuel].nbTerritoire() == 0);

        if(tt != clients.end() && (*tt).second != NULL)
        {
            sf::Packet pj;
            pj << eGAME_ETAT;
            (*tt).second->BR_partie->send( pj );

            pj.clear();
            pj << (sf::Uint8)eCOMBAT;
            (*tt).second->BR_partie->send( pj );
        }

        camps[joueurActuel].setEtat(eCOMBAT);

        for( std::map<string, Client*>::iterator tr = clients.begin(); tr != clients.end(); tr++)
        {
            if((*tr).second != NULL)
            {
                sf::Packet pp;
                pp << eGAME_NEXT;
                (*tr).second->BR_partie->send( pp );

                pp.clear();
                pp << eGAME_SELECTION;
                (*tr).second->BR_partie->send( pp );

                pp.clear();
                pp << (sf::Int8)-1 << (sf::Int8)-1;
                (*tr).second->BR_partie->send( pp );
            }
        }
    }

    cout << "J:" << joueurActuel << endl;
}



